home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 2010 April / PCWorld0410.iso / hity wydania / Ubuntu 9.10 PL / karmelkowy-koliberek-desktop-9.10-i386-PL.iso / casper / filesystem.squashfs / usr / share / hplip / base / mfpdtf.pyc (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2009-10-28  |  8.0 KB  |  291 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.6)
  3.  
  4. import struct
  5. import cStringIO
  6. from g import *
  7. from codes import *
  8. NEW_PAGE = 1
  9. END_PAGE = 2
  10. NEW_DOCUMENT = 4
  11. END_DOCUMENT = 8
  12. END_STREAM = 16
  13. RESERVED_20 = 32
  14. RESERVED_40 = 64
  15. RESERVED_80 = 128
  16. MFPDTF_RASTER_BITMAP = 0
  17. MFPDTF_RASTER_GRAYMAP = 1
  18. MFPDTF_RASTER_MH = 2
  19. MFPDTF_RASTER_MR = 3
  20. MFPDTF_RASTER_MMR = 4
  21. MFPDTF_RASTER_RGB = 5
  22. MFPDTF_RASTER_YCC411 = 6
  23. MFPDTF_RASTER_JPEG = 7
  24. MFPDTF_RASTER_PCL = 8
  25. MFPDTF_RASTER_NOT = 9
  26. DT_UNKNOWN = 0
  27. DT_FAX_IMAGES = 1
  28. DT_SCANNED_IMAGES = 2
  29. DT_DIAL_STRINGS = 3
  30. DT_DEMO_PAGES = 4
  31. DT_SPEED_DIALS = 5
  32. DT_FAX_LOGS = 6
  33. DT_CFG_PARMS = 7
  34. DT_LANG_STRS = 8
  35. DT_JUNK_FAX_CSIDS = 9
  36. DT_REPORT_STRS = 10
  37. DT_FONTS = 11
  38. DT_TTI_BITMAP = 12
  39. DT_COUNTERS = 13
  40. DT_DEF_PARMS = 14
  41. DT_SCAN_OPTIONS = 15
  42. DT_FW_JOB_TABLE = 17
  43. RT_START_PAGE = 0
  44. RT_RASTER = 1
  45. RT_END_PAGE = 2
  46. FIXED_HEADER_SIZE = 8
  47. IMAGE_VARIANT_HEADER_SIZE = 10
  48. DIAL_STRINGS_VARIANT_HEADER_SIZE = 6
  49. FAX_IMAGE_VARIANT_HEADER_SIZE = 74
  50. SOP_RECORD_SIZE = 36
  51. RASTER_RECORD_SIZE = 4
  52. EOP_RECORD_SIZE = 12
  53. DIAL_STRING_RECORD_SIZE = 51
  54. PAGE_FLAG_NEW_PAGE = 1
  55. PAGE_FLAG_END_PAGE = 2
  56. PAGE_FLAG_NEW_DOC = 4
  57. PAGE_FLAG_END_DOC = 8
  58. PAGE_FLAG_END_STREAM = 16
  59. SRC_UNKNOWN = 0
  60. SRC_HOST = 2
  61. SRC_SCANNER = 5
  62. SRC_HOST_THEN_SCANNER = 6
  63. SRC_SCANNER_THEN_HOST = 7
  64. TTI_NONE = 0
  65. TTI_PREPENDED_TO_IMAGE = 1
  66. TTI_OVERLAYED_ON_IMAGE = 2
  67. MAJOR_VER = 2
  68. MINOR_VER = 0
  69.  
  70. def parseFixedHeader(buffer):
  71.     fmt = '<IHBB'
  72.     (block_len, header_len, data_type, page_flags) = struct.unpack(fmt, buffer[:8])
  73.     page_flags = page_flags & 31
  74.     return (block_len, header_len, data_type, page_flags)
  75.  
  76.  
  77. def parseImageVariantHeader(buffer, data_type):
  78.     if data_type == DT_SCANNED_IMAGES:
  79.         fmt = '<BBHHHH'
  80.         (major_ver, minor_ver, src_pages, copies_per_page, zoom, jpeg_q_factor) = struct.unpack(fmt, buffer[:10])
  81.         return (major_ver, minor_ver, src_pages, copies_per_page, zoom, jpeg_q_factor)
  82.     if data_type == DT_FAX_IMAGES:
  83.         pass
  84.     
  85.  
  86.  
  87. def parseRecord(buffer):
  88.     record_type = struct.unpack('<B', buffer[0])[0]
  89.     if record_type == RT_START_PAGE:
  90.         fmt = '<BBHHHIIIHHIII'
  91.         (id, encoding, page_num, black_ppr, black_bpp, black_rpp, black_hort_dpi, black_vert_dpi, cmy_ppr, cmy_bpp, cmy_rpp, cmy_hort_dpi, cmy_vert_dpi) = struct.unpack(fmt, buffer[:SOP_RECORD_SIZE])
  92.         if not id == record_type:
  93.             raise AssertionError
  94.         return (id, (encoding, page_num, black_ppr, black_bpp, black_rpp, black_hort_dpi, black_vert_dpi, cmy_ppr, cmy_bpp, cmy_rpp, cmy_hort_dpi, cmy_vert_dpi))
  95.     if record_type == RT_RASTER:
  96.         fmt = '<BBH'
  97.         (id, unused, data_size) = struct.unpack(fmt, buffer[:RASTER_RECORD_SIZE])
  98.         if not id == record_type:
  99.             raise AssertionError
  100.         return (id, (unused, data_size))
  101.     if record_type == RT_END_PAGE:
  102.         fmt = '<BBBBII'
  103.         (id, unused1, unused2, unused3, black_rows, cmy_rows) = struct.unpack(fmt, buffer[:EOP_RECORD_SIZE])
  104.         if not id == record_type:
  105.             raise AssertionError
  106.         return (id, (unused1, unused2, unused3, black_rows, cmy_rows))
  107.     log.error('Error: Invalid record type: %d' % record_type)
  108.     raise Error(ERROR_INTERNAL)
  109.  
  110.  
  111. def readChannelToStream(device, channel_id, stream, single_read = True, callback = None):
  112.     (STATE_END, STATE_FIXED_HEADER, STATE_VARIANT_HEADER, STATE_RECORD) = range(4)
  113.     (state, total_bytes, block_remaining, header_remaining, data_remaining) = (1, 0, 0, 0, 0)
  114.     endScan = False
  115.     while state != STATE_END:
  116.         log.debug('**** State %d ****' % state)
  117.         if state == STATE_FIXED_HEADER:
  118.             if endScan:
  119.                 state = STATE_END
  120.                 break
  121.             
  122.             if data_remaining == 0:
  123.                 (fields, data) = device.readChannel(channel_id)
  124.                 data_remaining = len(data)
  125.                 if callback is not None:
  126.                     endScan = callback()
  127.                 
  128.             
  129.             (block_len, header_len, data_type, page_flags) = parseFixedHeader(data)
  130.             block_remaining = block_len - FIXED_HEADER_SIZE
  131.             header_remaining = header_len - FIXED_HEADER_SIZE
  132.             log.debug('Fixed header: (datalen=%d(0x%x),blocklen=%d(0x%x),headerlen=%d(0x%x),datatype=0x%x,pageflags=0x%x)' % (len(data), len(data), block_len, block_len, header_len, header_len, data_type, page_flags))
  133.             data_remaining -= FIXED_HEADER_SIZE
  134.             data = data[FIXED_HEADER_SIZE:]
  135.             state = STATE_RECORD
  136.             log.debug('Data: data=%d,block=%d,header=%d' % (data_remaining, block_remaining, header_remaining))
  137.             if page_flags & PAGE_FLAG_END_STREAM:
  138.                 state = STATE_END
  139.                 break
  140.             
  141.             if header_remaining > 0:
  142.                 state = STATE_VARIANT_HEADER
  143.             
  144.         header_remaining > 0
  145.         if state == STATE_VARIANT_HEADER:
  146.             if data_type == DT_SCANNED_IMAGES:
  147.                 (major_ver, minor_ver, src_pages, copies_per_page, zoom, jpeg_q_factor) = parseImageVariantHeader(data, data_type)
  148.                 log.debug('Variant header: (major/minor=%d/%d,src_pages=%d,copies_per_page=%d,zoom=%d,jpeg_q_factor=%d' % (major_ver, minor_ver, src_pages, copies_per_page, zoom, jpeg_q_factor))
  149.                 data = data[IMAGE_VARIANT_HEADER_SIZE:]
  150.                 block_remaining -= IMAGE_VARIANT_HEADER_SIZE
  151.                 header_remaining -= IMAGE_VARIANT_HEADER_SIZE
  152.                 data_remaining -= IMAGE_VARIANT_HEADER_SIZE
  153.             elif data_type == DT_FAX_IMAGES:
  154.                 log.error('Unsupported data type')
  155.             else:
  156.                 log.error('Unsupported data type')
  157.             log.debug('Data: data=%d,block=%d,header=%d' % (data_remaining, block_remaining, header_remaining))
  158.             if header_remaining > 0:
  159.                 log.error('Header size error.')
  160.                 state = STATE_END
  161.                 continue
  162.             
  163.             state = STATE_RECORD
  164.             if block_remaining == 0:
  165.                 state = STATE_FIXED_HEADER
  166.                 continue
  167.             continue
  168.             continue
  169.         if state == STATE_RECORD:
  170.             (record_type, record) = parseRecord(data)
  171.             if record_type == RT_START_PAGE:
  172.                 (encoding, page_num, black_ppr, black_bpp, black_rpp, black_hort_dpi, black_vert_dpi, cmy_ppr, cmy_bpp, cmy_rpp, cmy_hort_dpi, cmy_vert_dpi) = record
  173.                 log.debug('Start page record: (encoding=0x%x, page=%d)' % (encoding, page_num))
  174.                 data = data[SOP_RECORD_SIZE:]
  175.                 block_remaining -= SOP_RECORD_SIZE
  176.                 data_remaining -= SOP_RECORD_SIZE
  177.                 if block_remaining != 0:
  178.                     log.error('Block size error.')
  179.                     state = STATE_END
  180.                     continue
  181.                 
  182.                 if single_read:
  183.                     state = STATE_END
  184.                     continue
  185.                 state = STATE_FIXED_HEADER
  186.                 log.debug('Data: data=%d,block=%d,header=%d' % (data_remaining, block_remaining, header_remaining))
  187.                 continue
  188.             elif record_type == RT_RASTER:
  189.                 (unused, data_size) = record
  190.                 log.debug('Raster record: (data size=%d(0x%x))' % (data_size, data_size))
  191.                 data = data[RASTER_RECORD_SIZE:]
  192.                 block_remaining -= RASTER_RECORD_SIZE
  193.                 data_remaining -= RASTER_RECORD_SIZE
  194.                 log.debug('Data: data=%d,block=%d,header=%d' % (data_remaining, block_remaining, header_remaining))
  195.                 if block_remaining > 0 and data_remaining > 0:
  196.                     log.debug('Writing remainder of data...')
  197.                     data_len = len(data)
  198.                     log.debug('Data len=%d(0x%x)' % (data_len, data_len))
  199.                     stream.write(data[:block_remaining])
  200.                     block_remaining -= data_len
  201.                     data_remaining -= data_len
  202.                     if data_remaining != 0:
  203.                         log.error('Data size error')
  204.                         state = STATE_END
  205.                         continue
  206.                     
  207.                 
  208.                 while block_remaining > 0:
  209.                     if endScan:
  210.                         break
  211.                     
  212.                     log.debug('Reading more data from device...')
  213.                     (fields, data) = device.readChannel(channel_id)
  214.                     if callback is not None:
  215.                         endScan = callback()
  216.                     
  217.                     data_len = len(data)
  218.                     log.debug('Data len=%d(0x%x)' % (data_len, data_len))
  219.                     stream.write(data[:block_remaining])
  220.                     total_bytes += data_len
  221.                     block_remaining -= data_len
  222.                 if block_remaining != 0:
  223.                     log.error('Block size error.')
  224.                     state = STATE_END
  225.                     continue
  226.                 
  227.                 state = STATE_FIXED_HEADER
  228.                 continue
  229.             elif record_type == RT_END_PAGE:
  230.                 (unused1, unused2, unused3, black_rows, cmy_rows) = record
  231.                 log.debug('End page record: (black_rows=%d,cmy_rows=%d)' % (black_rows, cmy_rows))
  232.                 data = data[EOP_RECORD_SIZE:]
  233.                 block_remaining -= EOP_RECORD_SIZE
  234.                 data_remaining -= EOP_RECORD_SIZE
  235.                 if block_remaining != 0:
  236.                     log.error('Block size error.')
  237.                 
  238.                 log.debug('Data: data=%d,block=%d,header=%d' % (data_remaining, block_remaining, header_remaining))
  239.                 if page_flags & PAGE_FLAG_END_DOC or page_flags & PAGE_FLAG_END_STREAM:
  240.                     state = STATE_END
  241.                     continue
  242.                 state = STATE_FIXED_HEADER
  243.                 continue
  244.             
  245.         record_type == RT_START_PAGE
  246.     log.debug('Read %d bytes' % total_bytes)
  247.     return endScan
  248.  
  249.  
  250. def buildMFPDTFBlock(data_type, page_flags = 0, send_variant = False, data = None):
  251.     block = cStringIO.StringIO()
  252.     block.write(struct.pack('<I', 0))
  253.     header_len = FIXED_HEADER_SIZE
  254.     if send_variant:
  255.         if data_type == DT_DIAL_STRINGS:
  256.             header_len += DIAL_STRINGS_VARIANT_HEADER_SIZE
  257.         elif data_type == DT_FAX_IMAGES:
  258.             header_len += FAX_IMAGE_VARIANT_HEADER_SIZE
  259.         
  260.     
  261.     block.write(struct.pack('<H', header_len))
  262.     block.write(struct.pack('<B', data_type))
  263.     block.write(struct.pack('<B', page_flags))
  264.     if send_variant:
  265.         if data_type == DT_DIAL_STRINGS:
  266.             block.write(struct.pack('<BB', MAJOR_VER, MINOR_VER))
  267.             block.write(struct.pack('<H', 1))
  268.             block.write(struct.pack('<H', 51))
  269.         elif data_type == DT_FAX_IMAGES:
  270.             block.write(struct.pack('<BB', MAJOR_VER, MINOR_VER))
  271.             block.write(struct.pack('<B', SRC_HOST))
  272.             block.write(struct.pack('<H', 1))
  273.             block.write(struct.pack('<B', TTI_NONE))
  274.             block.write(struct.pack('<I', 0))
  275.             block.write('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')
  276.             block.write('                    ')
  277.             block.write('                    ')
  278.             block.write('<I', 0)
  279.         
  280.     
  281.     if data_type == DT_DIAL_STRINGS:
  282.         if data is not None:
  283.             dial_string = data['dial-string']
  284.             block.write(dial_string)
  285.             block.write('\x00' * (51 - len(dial_string)))
  286.         
  287.     elif data_type == DT_FAX_IMAGES:
  288.         pass
  289.     
  290.  
  291.